home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / PowerMacOberon feb96 / Source / Strings.Mod (.txt) < prev    next >
Oberon Text  |  1995-11-22  |  5KB  |  143 lines
  1. Syntax10.Scn.Fnt
  2. FoldElems
  3. Syntax10.Scn.Fnt
  4. (*-------------------------------------------------------------
  5. Strings provides a set of operations on strings (i.e., on string constants and character
  6. arrays, both of which contain the character 0X as a terminator). All positions in
  7. strings start at 0. 
  8. Strings.Length(s)
  9.     returns the number of characters in s up to and excluding the first 0X.
  10. Strings.Insert(src, pos, dst)
  11.     inserts the string src into the string dst at position pos (0 <= pos <= Length(dst)).
  12.     If pos = Length(dst), src is appended to dst. If the size of dst is not large enough
  13.     to hold the result of the operation, the result is truncated so that dst is always
  14.     terminated with a 0X.
  15. Strings.Append(s, dst)
  16.     has the same effect as Insert(s, Length(s), dst). 
  17. Strings.Delete(s, pos, n)
  18.     deletes n characters from s starting at position pos (0 <= pos < Length(s)).
  19.     If n > Length(s) - pos, the new length of s is pos. 
  20. Strings.Replace(src, pos, dst)
  21.     has the same effect as Delete(dst, pos, Length(src)) followed by an Insert(src, pos, dst). 
  22. Strings.Extract(src, pos, n, dst)
  23.     extracts a substring dst with n characters from position pos (0 <= pos < Length(src)) in src.
  24.     If n > Length(src) - pos, dst is only the part of src from pos to Length(src) - 1. If the size of
  25.     dst is not large enough to hold the result of the operation, the result is truncated so that
  26.     dst is always terminated with a 0X. 
  27. Strings.Pos(pat, s, pos)
  28.     returns the position of the first occurrence of pat in s after position pos (inclusive).
  29.     If pat is not found, -1 is returned. 
  30. Strings.Cap(s)
  31.     replaces each lower case letter in s by its upper case equivalent.
  32. -------------------------------------------------------------*)
  33. Syntax10i.Scn.Fnt
  34. StampElems
  35. Alloc
  36. 20 Nov 95
  37. Syntax10b.Scn.Fnt
  38. Syntax8i.Scn.Fnt
  39. Documentation
  40. MODULE Strings;    (*HM 94-06-22 / 
  41. PROCEDURE Length* (s: ARRAY OF CHAR): INTEGER;
  42.     VAR i: INTEGER;
  43. BEGIN
  44.     i := 0; WHILE (i < LEN(s)) & (s[i] # 0X) DO INC(i) END;
  45.     RETURN i
  46. END Length;
  47. PROCEDURE Append* (extra: ARRAY OF CHAR; VAR dest: ARRAY OF CHAR);
  48.     VAR n1, n2, i: INTEGER;
  49. BEGIN
  50.     n1 := Length(dest); n2 := Length(extra); i := 0;
  51.     WHILE (i < n2) & (i + n1 < LEN(dest)) DO dest[i + n1] := extra[i]; INC(i) END;
  52.     IF i + n1 < LEN(dest) THEN dest[i + n1] := 0X END
  53. END Append;
  54. PROCEDURE Insert* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  55.     VAR n1, n2, i: INTEGER;
  56. BEGIN
  57.     n1 := Length(dest); n2 := Length(source); 
  58.     IF pos < 0 THEN pos := 0 END;
  59.     IF pos > n1 THEN Append(dest, source); RETURN END;
  60.     IF pos + n2 < LEN(dest) THEN  (*make room for source*)
  61.         i := n1; (*move also 0X if it is there*)
  62.         WHILE i >= pos DO
  63.             IF i + n2 < LEN(dest) THEN dest[i + n2] := dest[i] END;
  64.             DEC(i)
  65.         END
  66.     END;
  67.     i := 0; WHILE i < n2 DO dest[pos + i] := source[i]; INC(i) END
  68. END Insert;
  69. PROCEDURE Delete* (VAR s: ARRAY OF CHAR; pos, n: INTEGER);
  70.     VAR len, i: INTEGER;
  71. BEGIN
  72.     len:=Length(s);
  73.     IF pos < 0 THEN pos:=0 ELSIF pos >= len THEN RETURN END;
  74.     IF pos + n < len THEN
  75.         i:=pos + n; WHILE i < len DO s[i - n]:=s[i]; INC(i) END;
  76.         IF i - n < LEN(s) THEN s[i - n]:=0X END
  77.     ELSE s[pos]:=0X
  78. END Delete;
  79. PROCEDURE Replace* (source: ARRAY OF CHAR; pos: INTEGER; VAR dest: ARRAY OF CHAR);
  80. BEGIN
  81.     Delete(dest, pos, pos + Length(source));
  82.     Insert(source, pos, dest)
  83. END Replace;
  84. PROCEDURE Extract* (source: ARRAY OF CHAR; pos, n: INTEGER; VAR dest: ARRAY OF CHAR);
  85.     VAR len, destLen, i: INTEGER;
  86. BEGIN
  87.     len := Length(source); destLen := SHORT(LEN(dest)) - 1;
  88.     IF pos < 0 THEN pos := 0 END;
  89.     IF pos >= len THEN dest[0] := 0X; RETURN END;
  90.     i := 0;
  91.     WHILE (pos + i <= LEN(source)) & (source[pos + i] # 0X) & (i < n) DO
  92.         IF i < destLen THEN dest[i] := source[pos + i] END;
  93.         INC(i)
  94.     END;
  95.     dest[i] := 0X
  96. END Extract;
  97. PROCEDURE Pos* (pattern, s: ARRAY OF CHAR; pos: INTEGER): INTEGER;
  98.     VAR n1, n2, i, j: INTEGER;
  99. BEGIN
  100.     n1 := Length(s); n2 := Length(pattern);
  101.     IF n2 = 0 THEN RETURN 0 END;
  102.     i := pos;
  103.     WHILE i <= n1 - n2 DO
  104.         IF s[i] = pattern[0] THEN
  105.             j := 1; WHILE (j < n2) & (s[i + j] = pattern[j]) DO INC(j) END;
  106.             IF j = n2 THEN RETURN i END
  107.         END;
  108.         INC(i)
  109.     END;
  110.     RETURN -1
  111. END Pos;
  112. PROCEDURE Cap* (VAR s: ARRAY OF CHAR);
  113.     VAR i: INTEGER;
  114. BEGIN
  115.     i := 0;
  116.     WHILE s[i] # 0X DO
  117.         IF ("a" <= s[i]) & (s[i] <= "z") THEN s[i] := CAP(s[i]) END;
  118.         INC(i)
  119. END Cap;
  120. PROCEDURE Match* (string, pattern: ARRAY OF CHAR): BOOLEAN;
  121.     PROCEDURE M (VAR name, mask: ARRAY OF CHAR; n, m: INTEGER): BOOLEAN;
  122.     BEGIN
  123.         WHILE (n >= 0) & (m >= 0) & (mask[m] # "*") DO
  124.             IF name[n] # mask[m] THEN RETURN FALSE END;
  125.             DEC(n); DEC(m)
  126.         END;
  127.         (* ----- name empty | mask empty | mask ends with "*" *)
  128.         IF m < 0 THEN RETURN n < 0 END;
  129.         (* ----- name empty | mask ends with "*" *)
  130.         WHILE (m >= 0) & (mask[m] = "*") DO DEC(m) END;
  131.         IF m < 0 THEN RETURN TRUE END;
  132.         (* ----- name empty | mask still to be matched *)
  133.         WHILE n >= 0 DO
  134.             IF M(name, mask, n, m) THEN RETURN TRUE END;
  135.             DEC(n)
  136.         END;
  137.         RETURN FALSE
  138.     END M;
  139. BEGIN
  140.     RETURN M(string, pattern, Length(string)-1, Length(pattern)-1)
  141. END Match;
  142. END Strings.
  143.